Files C#

ACDC 2027


Lire / Ecrire dans un fichier - Méthode 1


Pour lire et écrire dans un fichier en csharp, il faut demander à l'ordinateur de créer un chemin entre le fichier et notre prograamme. Il existe alors deux méthode pour lire et écrire dans un fichier en csharp, la première consiste à manipuler explicitement les Stream et la deuxième consiste à utiliser les méthodes de la classe File du namespace System.IO.

Voyons d'abort la première méthode.

Pour ouvrir un fichier en mode lecture, on utilise un stream particulier appelé StreamReader. StreamReader est une classe, donc comme toute classe elle possède des constructeurs, voici celui qui nous intéresse:

Prototype(s)
public StreamReader(string path);


Pour ouvrir un fichier en mode écriture, on utilise un stream particulier appelé StreamWriter. StreamWriter est une classe, donc comme toute classe elle possède des constructeurs, voici celui qui nous intéresse:

Prototype(s)
public StreamWriter(string path);

Donc pour ouvrir un fichier, je dois donc d'abord ouvrir un stream, pour cela il existe deux méthodes différentes:

Basic way


Code example(s)
using System.IO;

try
{
  StreamReader sr = new StreamReader("file.txt"); // ou StreamWriter sw = new StreamWriter("file.txt");
  // read/write file
  sr.Close(); // ou sw.Close();
}
catch
{
  // handle exception
}

Bon essayons maintenant de comprendre ce code:

  • On commence par inclure le namespace System.IO qui contient la classe StreamReader.
  • On essaie d'ouvrir un stream vers le fichier file.txt en utilisant le constructeur StreamReader(string).
  • On lit/écrit le fichier.
  • On ferme le stream.

Fermer le stream
Il est très important, CHAQUE FOIS que vous ouvrez un stream, de le fermer. Faites-le avant de faire quoi que ce soit d'autre, et vous éviterez d'oublier. Oublier de fermer un stream peut entraîner de nombreux problèmes inattendus (et la moulinette ne sera pas contente).

Les exceptions
Attention à gérer les exceptions lors de la lecture/écriture de fichiers. Par exemple si vous n'acez pas les droits sur un fichier, une exception sera levée. Pour éviter cela, on utilise un bloc try-catch.


Usings


Code example(s)
try
{
  using (StreamReader sr = new StreamReader("file.txt")) // ou StreamWriter sw = new StreamWriter("file.txt")
  {
    // read/write file
  }
}
catch
{
  // handle exception
}

Ici, même concept que juste au dessus, à deux différences près:
  • On utilise le mot clé using
  • On utilise pas le mot clé Close pour fermer le stream

En fait mot clé using est une sorte de raccourci pour ouvrir un stream et le fermer automatiquement à la fin du bloc. C'est une bonne pratique de l'utiliser pour éviter d'oublier de fermer un stream. Vous serez alors sûr que dans tous les cas, le stream sera fermé.

Vous l'aurez donc compris, pour lire un fichier en csharp on utilise un stream de type StreamReader.

Mais uen fois ce stream ouvert, comment lire le fichier? Et bien c'est très simple, pour cela il existe plusieurs méthodes dans la classe StreamReader:

Prototype(s)
public string ReadLine(); // lit une ligne
public string ReadToEnd(); // lit tout le fichier à partir de la position actuelle
public int Read(); // lit un caractère

Warning(s)
Attention, si vous essayez de lire un fichier qui n'existe pas, une exception sera levée.

Maintenant voyons plusieurs exemples de code pour lire un fichier:


Lire une ligne


Code example(s)
using System.IO;

try
{
    using (StreamReader sr = new StreamReader("file.txt"))
    {
        string line = sr.ReadLine();
        if (line != null)
            Console.WriteLine(line);
        else
            Console.WriteLine("File is empty");
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be read:");
}

Essayons de comprendre ce code:
La fonction ReadLine permet de lire une ligne du fichier. Si la ligne ça veut dire qu'on a atteint la fin du fichier.

Quand j'ouvre un stream, la position de lecture est au début du fichier. Donc ici, n'ayant qu'un appel à ReadLine, je vais lire la première ligne du fichier.

Si le fichier n'a pas de 1ere ligne (est vide), la fonction ReadLine retourne null. On peut alors afficher un message pour dire que le fichier est vide.



Lire un fichier ligne par ligne


Code example(s)
using System.IO;

try
{
    using (StreamReader sr = new StreamReader("file.txt"))
    {
        string line;
        while ((line = sr.ReadLine()) != null)
        {
            Console.WriteLine(line);
        }
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be read:");
}

Comme vous l'aurez surement compris maintenant, le Stream conserve un curseur la position de lecture. Donc à chaque appel à ReadLine, le curseur vient se placer à la fin de la ligne. Ainsi au prochain appel à ReadLine, on lira la ligne suivante, et ainsi de suite jusqu'à la fin du fichier.

La syntaxe while ((line = sr.ReadLine()) != null) peut peut-être vous surprendre. En fait, il est possible d'affecter une valeur à une variable dans une condition, le tout est de le mettre entre parentheses. Ainsi, ici, à chaque tour de boucle quand on arrive sur la condition, on lit une nouvelle ligne et on vérifie que l'on est pas arrivé à la fin du fichier (que ma ligne n'est pas null).

Prenons un exemple pour mieux comprendre:

file.txt
I
love
my
ACDCs

Décomposons le code:
  1. On ouvre un stream vers le fichier file.txt
    • On lit la première ligne, elle n'est pas nulle (line="I"). On l'affiche donc. Le curseur est déplacé ligne 2.
    • On lit la deuxième ligne, elle n'est pas nulle (line="love"). On l'affiche donc. Le curseur est déplacé ligne 3.
    • On lit la troisième ligne, elle n'est pas nulle (line="my"). On l'affiche donc. Le curseur est déplacé ligne 4.
    • On lit la quatrième ligne, elle n'est pas nulle (line="ACDC"). On l'affiche donc. Le curseur est déplacé ligne 5.
    • On lit la cinquième ligne, elle est nulle. On sort de la boucle.
  4. Le fichier est automatiquement fermé à la fin du bloc using

Hint(s)
Quand vous lisez un fichier, ReadLine différencie les lignes vides et la fin du fichier. Si vous lisez une ligne vide, la fonction retourne une chaine vide ("". Si vous lisez la fin du fichier, la fonction retourne null.



Lire tout le fichier d'un coup


Code example(s)
using System.IO;

try
{
    using (StreamReader sr = new StreamReader("file.txt"))
    {
        string file = sr.ReadToEnd();
        Console.WriteLine(file);
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be read:");
}

La fonction ReadToEnd permet de lire tout le fichier à partir de la position actuelle. Ici, la position actuelle est au début du fichier. Donc on lit tout le fichier.

La fonction ReadToEnd retourne une string. On peut alors l'afficher.

Warning(s)
Attention, la fonction ReadToEnd ne lit pas tout le fichier, il lit tout le fichier à partir de la position actuelle. Donc si vous avez déjà lu une ligne, la fonction lira le fichier à partir de la ligne suivante.

Pour écrire dans un fichier en csharp on utilise un stream de type StreamWriter.

Mais une fois ce stream ouvert, comment écrire dans le fichier? Et bien c'est très simple, pour cela il existe plusieurs méthodes dans la classe StreamWriter:

Prototype(s)
public void Write(string value); // écrit une chaine
public void WriteLine(string value); // écrit une chaine et saute une ligne
public void Write(char value); // écrit un caractère
public void WriteLine(); // saute une ligne

Maintenant voyons un exemple de code pour écrire dans un fichier:

Code example(s)
using System.IO;

try
{
    using (StreamWriter sw = new StreamWriter("file.txt"))
    {
        sw.WriteLine("I");
        sw.Write("lo");
        sw.WriteLine("ve");
        sw.Write("my");
        sw.WriteLine();
        sw.Write('A');
        sw.Write("CD");
        sw.WriteLine("Cs");
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be written:");
}

file.txt
I
love
my
ACDCs

Essayons de comprendre ce code:
  1. On ouvre un stream vers le fichier file.txt
    • On écrit la chaine "I" dans le fichier (sautant une ligne)
    • On écrit la chaine "lo" dans le fichier (sans saut de ligne)
    • On écrit la chaine "ve" dans le fichier (sautant une ligne)
    • On écrit la chaine "my" dans le fichier (sans saut de ligne)
    • On saute une ligne
    • On écrit le caractère 'A' dans le fichier (sans saut de ligne)
    • On écrit la chaine "CD" dans le fichier (sans saut de ligne)
    • On écrit la chaine "Cs" dans le fichier (sautant une ligne)
  3. Le fichier est automatiquement fermé à la fin du bloc using

Hint(s)
Tu sais quoi ? Tu connaissais toutes ces méthodes, en effet c'est les même que tu utilises pour afficher des messages dans la console. C'est pas beau ça?

Cependant attention, si le fichier existe déjà, la méthode StreamWriter écrasera le contenu du fichier. Si vous voulez ajouter du contenu à un fichier existant, il faudra rajouter le paramètre true au constructeur de StreamWriter pour activer le mode append.

Code example(s)
using System.IO;

try
{
    using (StreamWriter sw = new StreamWriter("file.txt", true)) // true pour activer le mode append
    {
        sw.WriteLine("I append to my file instead of overwriting it");
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be written:");
}

file.txt
I
love
my
ACDCs
I append to my file instead of overwriting it

Hint(s)
On part du principe ici du principe qu'on récupère le fichier file.txt que l'on a créé précédemment.

Information
Si un fichier n'existe pas, il sera créé automatiquement. Si le dossier dans lequel vous voulez écrire n'existe pas, une exception sera levée.


Lire / Ecrire dans un fichier - Méthode 2


Voyons désormais la deuxième méthode pour lire/écrire dans des fichiers, elle consiste à utiliser les méthodes de la classe File du namespace System.IO.

Pour lire dans un fichier en csharp, on peut utiliser les méthodes suivantes de la classe File.

Prototype(s)
public static string ReadAllText (string path);
public static string[] ReadAllLines (string path);

Voyons quelques exemples de code pour lire un fichier:

Lire tout le fichier d'un coup


Code example(s)
using System.IO;

try
{
    string file = File.ReadAllText("file.txt");
    Console.WriteLine(file);
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be read:");
}

La méthode ReadAllText permet de lire tout le fichier d'un coup. Elle retourne une string contenant tout le contenu du fichier.

Lire le fichier ligne par ligne


Code example(s)
using System.IO;

try
{
    string[] lines = File.ReadAllLines("file.txt");
    foreach (string line in lines)
    {
        Console.WriteLine(line);
    }
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be read:");
}

La méthode ReadAllLines permet de lire le fichier ligne par ligne. Elle retourne un tableau de string ou chaque élément du tableau correspond à une ligne du fichier.

Il ne vous reste plus qu'à parcourir le tableau pour afficher chaque ligne.

Pour écrire dans un fichier en csharp, on peut utiliser les méthodes suivantes de la classe File.

Prototype(s)
public static void WriteAllText (string path, string contents);
public static void WriteAllLines (string path, string[] contents);

Voyons quelques exemples de code pour écrire dans un fichier:

Ecrire tout le fichier d'un coup


Code example(s)
using System.IO;

try
{
    File.WriteAllText("file.txt", "I\nlove\nmy\nACDCs");
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be written:");
}

La méthode WriteAllText permet d'écrire tout le contenu du fichier d'un coup. Le premier paramètre est le chemin du fichier, le deuxième est le contenu à écrire.

Ecrire le fichier ligne par ligne


Code example(s)
using System.IO;

try
{
    string[] lines = { "I", "love", "my", "ACDCs" };
    File.WriteAllLines("file.txt", lines);
}
catch (Exception ex)
{
    Console.WriteLine("The file could not be written:");
}

La méthode WriteAllLines permet d'écrire le contenu du fichier ligne par ligne. Le premier paramètre est le chemin du fichier, le deuxième est un tableau de string contenant les lignes à écrire.

Il ne vous reste plus qu'à parcourir le tableau pour écrire chaque ligne.

Danger(s)
Cependant attention, si le fichier existe déjà, les méthodes WriteAllText et WriteAllLines écraseront le contenu du fichier. Si vous voulez ajouter du contenu à un fichier existant, il faudra utiliser les méthodes AppendAllText et AppendAllLines de la classe File, qui fonctionnent de la même manière que les méthodes WriteAllText et WriteAllLines mais ajoutent le contenu au fichier au lieu de l'écraser.


Créer / Supprimer des fichiers


Pour créer un fichier en csharp, il suffit d'utiliser la classe File du namespace System.IO. Voici un exemple de code pour créer un fichier:

Prototype(s)
public static System.IO.FileStream Create (string path);

Code example(s)
using System.IO;

try
{
    File.Create("file.txt").Close();
}
catch (Exception ex)
{
    // handle exception
}

Danger(s)
Le code ci-dessus crée un fichier nommé `file.txt` dans le répertoire courant. Si le fichier existe déjà, il sera écrasé.

Les exceptions
Attention à gérer les exceptions lors de la création de fichiers. Par exemple si vous n'avez pas les droits d'écriture dans le répertoire ciblé, une exception sera levée.

Un stream ouvert
La méthode `File.Create` retourne un `Stream` ouvert. Il est donc nécessaire de le fermer (avec la méthode Close ou Dispose) pour éviter tout problème.

Pour supprimer un fichier en csharp, il suffit d'utiliser la méthode Delete de la classe File du namespace System.IO. Voici un exemple de code pour supprimer un fichier:

Prototype(s)
public static void Delete (string path);

Code example(s)
using System.IO;

try
{
    File.Delete("file.txt");
}
catch (Exception ex)
{
    // handle exception
}

Les exceptions
Attention à gérer les exceptions lors de la suppression de fichiers. Par exemple si le fichier n'existe pas, une exception sera levée.

Fichier en cours d'utilisation
Si le fichier est en cours d'utilisation par un autre processus, une exception sera levée lors de la suppression.



This page and all subpages are for internal use at EPITA only.
The use of this document must abide by the following rules:
Copyright © 2024-2025 - EPITA